package com.yuntsg.ruiijn.paperana.test;

import cn.hutool.core.io.FileUtil;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.indices.CreateIndexResponse;
import com.yuntsg.ruiijn.paperana.utils.esutils.IndexConfig;
import common.util.StringUtil;
import common.util.VerifyUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.servlet.support.RequestContext;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;

/**
 * @Author: gcr
 * @Date: 2023/10/25 16:39
 */
@Service
@Slf4j
public class FirstStart {

    @Value("${upload.path}")
    public String uploadPath;

    @Resource
    HttpServletRequest request;

    @Resource
    ElasticsearchClient elasticsearchClient;

    public static void createTextIndexLocal(ElasticsearchClient client, String indexName) {
        try {
            if (client.indices().exists(b -> b.index(indexName)).value()) {
                log.info("存在不创建文字库");
                return;
            }
            // 创建连接 创建索引库 库名 这是创建临时库
            CreateIndexResponse createIndexResponse =
                    client.indices().create(c -> c.index(indexName)//库名表
                            /*这个是Index名字,可以直接字符串*/
                            .settings(indexSettingsBuilder -> indexSettingsBuilder.numberOfReplicas("0").numberOfShards("3"))
                            .mappings(o -> o
                                    //设置字段名称和类型 当前主要是分词就够用了
                                    .properties("database_type", i -> i.text(p -> p))
                                    .properties("sentence", i -> i.text(p -> p))
                                    .properties("database_type", i -> i.text(p -> p))
                                    // 这个就是默认文字检索 不需要其他属性了
                                    .properties("str", i -> i.text(p -> p
                                            .analyzer("ik_max_word")
                                            .searchAnalyzer("ik_max_word")
                                            .fields("keyword", r -> r.keyword(m -> m.normalizer("lowercase")))))
                                    .properties("sub_project", i -> i.text(p -> p))
                                    .properties("file_id", i -> i.text(p -> p))
                                    .properties("table_id", i -> i.text(p -> p))
                            ));
            // 打印结果
            System.out.println(createIndexResponse.acknowledged());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        ElasticsearchClient esClient = IkChina.getEsClient();
//        createTextIndex(esClient, IndexConfig.UNIT_INDEXTEST);
    }

    // 创建es 自定义文字库
    public void createTextIndex(String indexName) {
        try {
            boolean value = elasticsearchClient.indices().exists(b -> b.index(indexName)).value();
            log.info("文字库存在吗indexName?+" + indexName + "++" + value);
            if (value) {
                log.info("存在不创建文字库");
            } else {
                log.info("不存在++++++++++++创建文字库");
                // 创建连接 创建索引库 库名 这是创建临时库
                CreateIndexResponse createIndexResponse =
                        elasticsearchClient.indices().create(c -> c.index(indexName)//库名表
                                /*这个是Index名字,可以直接字符串*/
                                .settings(indexSettingsBuilder -> indexSettingsBuilder.numberOfReplicas("0").numberOfShards("4"))
                                .mappings(o -> o
                                        //设置字段名称和类型 当前主要是分词就够用了
                                        .properties("database_type", i -> i.text(p -> p))
                                        .properties("sentence", i -> i.text(p -> p))
                                        .properties("database_type", i -> i.text(p -> p))
                                        // 这个就是默认文字检索 不需要其他属性了
                                        .properties("str", i -> i.text(p -> p
                                                .analyzer("ik_max_word")
                                                .searchAnalyzer("ik_max_word")
                                                .fields("keyword", r -> r.keyword(m -> m.normalizer("lowercase")))))
                                        .properties("sub_project", i -> i.text(p -> p))
                                        .properties("file_id", i -> i.text(p -> p))
                                        .properties("table_id", i -> i.text(p -> p))
                                ));
                // 打印结果
                System.out.println(createIndexResponse.acknowledged());
                boolean value2 = elasticsearchClient.indices().exists(b -> b.index(indexName)).value();
                log.info("创建后检查+" + indexName + "++" + value2);

            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    // 第一次启动 判断基本配置文件模板是不是在路径下 没有自动部署过去 以后转移服务器不再在路径下放置文件
    public void CheckFirstStart() {
        if (VerifyUtil.isServer()) {
            log.info("测试开始 测试模板路径");
            String fromPath = uploadPath + "template/articleRes3.docx";
            String fromPathRuijin = uploadPath + "template/articleRes2ruijin.docx";
            String licensePath = "/data/analysis/license.xml";
            log.info("当前项目路径++" + getPath());
//            log.info("当前项目路径Real方法++" + getPathReal());
            // 直接覆盖 防止改了版本不一致
//            if (FileUtil.exist(fromPath)) {
//                log.info("文字模板存在articleRes");
//            } else {
//                log.info("word template no exist do copy");
//
//
//            }
            File fileLocal = new File(getPath() + "WEB-INF/classes/articleRes3.docx");
            File newFLocal = new File(fromPath);
            FileUtil.copy(fileLocal, newFLocal, true);


//            if (FileUtil.exist(fromPathRuijin)) {
//                log.info("文字模板存在articleResruijin");
//            } else {
//                log.info("word template no exist do copy");
//                log.info("当前项目路径++" + getPath());
//
//            }
            File fileruiin = new File(getPath() + "WEB-INF/classes/articleRes2ruijin.docx");
            File newFruijin = new File(fromPathRuijin);
            FileUtil.copy(fileruiin, newFruijin, true);
            if (FileUtil.exist(licensePath)) {
                log.info("word license存在");
            } else {
                log.info("word license no exist");
                log.info("当前项目路径++" + getPath());
                // WEB-INF/classes/
                File file = new File(getPath() + "WEB-INF/classes/license.xml");
                File newF = new File(licensePath);
                FileUtil.copy(file, newF, true);
            }
            log.info("新的模板路径存在吗?++" + FileUtil.exist(fromPath));
            log.info("新的模板路径存在吗?++" + FileUtil.exist(fromPathRuijin));
            log.info("新的license路径存在吗?++" + FileUtil.exist(licensePath));
            log.info("测试es本地文字库存在吗");
            System.out.println(IndexConfig.SELF_TETX_INDEX);
            createTextIndex(IndexConfig.SELF_TETX_INDEX);
            log.info("测试全部结束");
        }
    }


    private String getPath() {
        //服务器: tomcat/webapps/root
        //windows: 工作路径/项目名

        try {
            String root = RequestContext.class.getResource("/").getFile();
            String a = new File(root).getParentFile().getParentFile().getCanonicalPath();
            if (StringUtil.isNotNull(a) && a.equals("/")) {
                String path = this.getClass().getClassLoader().getResource("").getPath();
                log.info("path++" + path);
                if (!path.endsWith("/")) {
                    path = path + "/";
                }
                return path;
            } else {
                if (!a.endsWith("/")) {
                    a = a + "/";
                }
                log.info("aaaapath++" + a);
                return a;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

//    private String getPathReal() {
//        //服务器: tomcat/webapps/root
//        //windows: 工作路径/项目名
//        // 此方法只适用于非tomcat 启动才可以
//        String projectPath = System.getProperty("user.dir") + "/";
//        log.info("项目路径：" + projectPath);
//        return projectPath;
//
//    }


}
